Dynamically generating documents using natural language processing of apparatus claims

ABSTRACT

Disclosed are systems, apparatuses, processes, and computer-readable media to convert apparatus and method claims into patent application disclosure. A process includes displaying a user interface for writing a patent application, the user interface including a plurality of objects that can be converted into content for the patent application; displaying a claim based on phrases that are separated based on a phrase variant, the phrase variant including at least one of an adjective phrase and a verb phrase; determining that a first phrase of the claim is dragged in the user interface and dropped into an object of the plurality of objects; creating and displaying a first object within the user interface based on the first phrase; and converting the plurality of objects in the user interface into the patent application including content based on the plurality of objects within the user interface

CROSS-REFERENCE TO RELATED APPLICATIONS

This application claims the benefit of U.S. provisional applicationnumber 63/193,981, filed on May 27, 2021, which is expresslyincorporated by reference herein in its entirety.

TECHNICAL FIELD

The present technology pertains to a method and apparatus for generatingdocuments using natural language processing and a dynamic userinterface.

BACKGROUND

Formal documents that are authored for administrative agencies arerequired to have a specific structure to comport with requirements ofthe administrative agency. The requirements include procedural-basedrequirements (e.g., margins, font size, etc.) and statutory-basedrequirements (content).

BRIEF DESCRIPTION OF THE DRAWINGS

In order to describe the manner in which the above-recited and otheradvantages and features of the disclosure can be obtained, a moreparticular description of the principles briefly described above will berendered by reference to specific embodiments thereof which areillustrated in the appended drawings. Understanding that these drawingsdepict only exemplary embodiments of the disclosure and are nottherefore to be considered to be limiting of its scope, the principlesherein are described and explained with additional specificity anddetail through the use of the accompanying drawings in which:

FIGS. 1 and 2 illustrate conventional systems for generating a patentspecification;

FIG. 3 illustrates a sequence diagram of an example system fordynamically generating documents using natural language processing(NLP), in accordance with some examples;

FIG. 4 illustrates an example method for analyzing claims for generatingdescriptions for a patent application irrespective of statutory form, inaccordance with some examples;

FIGS. 5A to 5E are various example claims that are analyzed based on thedisclosed methods to illustrate identification of descriptive phrases,functional phrases, and linking phrases, in accordance with someexamples;

FIG. 6 illustrates a conceptual diagram illustrating a method toidentify a context and a subject of different lines of the claim inaccordance with some examples;

FIG. 7 illustrates a graph illustrating a relationship of variouscontexts and phrases identified in the claim 600 in accordance with someexamples;

FIG. 8 illustrates an example method for visually building aspecification description from an apparatus claim in accordance withsome examples;

FIG. 9 illustrates a function of an application for normalizing claimterms with various content within a drawing in accordance with someexamples;

FIG. 10 illustrates a function of an application using phrases tovisually prepare a description associated with an apparatus claim inaccordance some examples;

FIG. 11 illustrates another function of an application that usesintuitive input to visually prepare, organize, and draft an applicationusing apparatus claims in accordance with some examples;

FIG. 12 illustrates an example computer system for executing client orserver operations, in accordance with some examples; and

FIG. 13 illustrates an example of a computing system in accordance withsome examples.

DESCRIPTION

Various embodiments of the disclosure are discussed in detail below.While specific implementations are discussed, it should be understoodthat this is done for illustration purposes only. A person skilled inthe relevant art will recognize that other components and configurationsmay be used without parting from the spirit and scope of the disclosure.

As machine learning, especially natural language processing (NLP) becomemore robust it is tempting to look to these tools to perform certaintasks that are considered formulaic. While these tools are indeedbeneficial, they are not suitable for producing completed work productin most instances. Machine learning tools are not yet able to take rawinputs, understand them, and write an explanatory document about thoseraw inputs. Therefore previous attempts at document creation usingmachine learning tools have focused on using structured inputs.

In the example tools used for drafting patent applications, a commonstructured input has been claims. Indeed those skilled in the art ofdrafting patent applications often begin with claims because they arethe most important part of the document, and are designed to recite thenovel aspects of an invention. However, such tools are limited torestructuring clauses of claims into sentences and pasting them into adocument, which is insufficient to produce any useful work product.Further, existing tools only use method claims as inputs because methodclaims are predictable and structure can be inferred based on a gerundverb phrase (e.g., “transmitting a message”) and identifying non-gerundphrases based on inferences and lack of gerund verbs. Other types ofclaims, such as apparatus or system claims, have a larger amount ofvariety and cannot be handled based on inferences.

In other examples, the existing tools only repeat the claims in theorder they are input via the document and do not distinguish between thedifferences in the claims. In a patent application, a dependent claimcould occur before the first limitation of an independent claim, couldoccur after the last limitation of the independent claim, or occuranywhere in between the first and last limitations. Moreover, adependent claim may add subject matter or may further define previousactions. For example, a passive phrase in a dependent claim furtherdefines subject matter to which it refers. Further, an active phrase maybe defined by additional active phrases. The dependent claims mayencompass multiple embodiments that are mutually exclusive (i.e.,different species).

Existing tools may only generate a drawing based on the independentmethod claim, thereby producing an incomplete drawing. Further, theexisting systems are also unable to identify condition-action sequences(e.g., if a condition is satisfied, perform a function) that would causethe flowchart to have branching logic because NLP itself is unable todisambiguate the meaning of phrases. The existing systems are alsounable to represent inherent conditions, thus omitting content in thedrawing that should be explicit.

The present technology improves over existing solutions by allowinginput of any type of claim, whether apparatus, device, or system bydistinguishing between descriptive phrases and functional phrases,irrespective of the root of the phrase. In some examples, a descriptivephrase describes an object (e.g., a processor connected to a memory),and a functional phrase describes a function of an object (e.g., aprocessor configured to process contents). The methods disclosed hereinallow disambiguation of these different phrase types to allow eachdifferent phrase to be converted into a sentence. However, thedescriptive phrases and functional phrases are different than previouslydisclosed verb phrases and adjective phrases because the prior phrasetypes (the verb phrase and the adjective phrase) use the root token asthe premise of the type of phrase. The descriptive functional phrasesand descriptive are different because the root token provides context,but both descriptive and functional phrases can include root tokens thatare either a noun or a verb. For example, “a processor configured toprocess information” is a functional phrase even though the root tokenis a noun (the processor). By identifying functional and descriptivephrases, any type of claim can be disambiguated, such as claims relatedto a mechanical structure.

The present technology can perform functions previously that have beenimpossible, such as the conversion of apparatus into method claims.Conventional technology only converts method claims into apparatusclaims by adding generic language (e.g., a processor configured to”) andchanging conjugations of the gerund verbs (e.g., “processing the data”to “process the data”) to yield an apparatus recitation (e.g., “aprocessor configured to process the data”). The present technology alsoallows additional inputs (e.g., drawings) that can be combined withnatural language processing to automatically generate descriptions ofthe input drawings.

By enabling the processing of apparatus claims, the present technologycan be used to further automate tasks for application drafters andprovide a usable draft of an application that discloses the claims,irrespective of the type of claim. Allowing different types of claiminputs allow patent drafting automation software to be extended frompurely functional subject matter to concepts that include structure, andmix structure and function (e.g., electrical circuits, mechanicalstructures, electro-mechanical, etc.). In some aspects, the presenttechnology can provide prompts to a user to provide disambiguation forterms, or to provide additional descriptive details. In this way, thepresent technology can encourage the user to provide additional inputthat may be beneficial to the NLP analysis.

A goal of the present technology is to provide the output that providesefficiency to an author, while leaving room for an author to provide theingenuity and thoughtfulness that only a human author can provide. Theseand other improvements to tools that use algorithms or NLP to createdocuments are described herein.

FIGS. 1 and 2 illustrate systems for generating patent applications. Inparticular, FIG. 1 illustrates a server-based process to generate theformal document, and FIG. 2 illustrates an application-based generationprocess to generate the patent specification. In general, each of thesesystems generally receives method claims as input and (1) converts themethod claims into apparatus or device claims, (2) generates adescription of a flowchart-based on a set of method claims (i.e., asingle independent claim and generally at least one dependent claim thatdepends from that single independent claim), and (3) creates a singlegeneric flowchart diagram based on the independent claim. The systemsmay also be able to insert generic device descriptions and boilerplatebased on a client's requirements.

Referring to FIG. 1 , a system 100 comprises a client 110 that connectsto a webserver 120 for generating the patent specification. In thesystem 100, the client 110 transmits a document at step 135 thatincludes a set of method claims to the webserver 120. Having receivedthe document with method claims, the webserver 120 extracts the methodclaims from the document at step 140. After extracting the claim, thewebserver 120 transmits text that corresponds to the method claims to anatural language processing (NLP) server at step 145

The NLP server 130 receives the text and processes the text into NLPtokens at step 150. An NLP token (or token) is generally a single wordor a single character (e.g., punctuation) and is assigned severalproperties. For instance, each NLP token is generally assigned anidentifier (ID), a part of speech tag that identifies the part of speech(e.g., noun, verb, etc.), and a dependency label that identifies how thepart of speech depends on other tokens, and so forth. In general, NLPengines also assign what is referred to as a fine part of speech, whichfurther clarifies the purpose of that word. For example, a noun can bethe object of the sentence, but could also be part of a compound noun(that is, a single object that has a name including several words),which is also referred to as an n-gram.

A dependency label identifies how the token depends on other tokens. Forexample, an NLP token may be a determiner (i.e., an article such as“the” or “an”), a nominal subject, a clausal subject, an adverbialclause, conjunction, punctuation, and so forth. A dependency labelreferred to as root corresponds to the root of the sentence or phraseand is not dependent on any other tokens in that sentence. For example,in the sentence “I love fries,” the NLP token “love” is the root, “I” isthe proper noun having a dependency of noun subject from the root, and“fries” is the noun that is a direct object of the root. For example,the output of this sentence is illustrated in Table 1 below.

TABLE 1 Id RootId Text Course Tag Fine Tag Dependency Label 0 1 I NounPersonal Pronoun Nominal Subject 1 1 love Verb Non-3^(rd) person Rootpresent verb 2 1 fries Noun Plural Noun Direct Object

The NLP server 130 transmits the tokens to the webserver 120 at step155, which converts the tokens into a patent specification at step 160.The webserver 120 creates a flowchart and a corresponding description tothat flowchart based on NLP tokens from the method claims. To create thedescription of the flowchart, the webserver 120 extracts the individualportions of tokens that can be converted into a single sentence based onthe order in which they are identified in the method claim (i.e., text).

Specifically, the webserver 120 converts an active step, which is aclause having an active gerund as its root word, into a sentence using adifferent tense. For example, the webserver 120 may convert a phrase“performing a function” into “perform a function” and then add genericcontent such as “a processor may” to the beginning of the phrase, thusforming “a processor may perform a function.” In this case, the genericstructure is predetermined and not associated with user input. That is,the webserver 120 receives the method claims in a particular sequenceand then generates a flowchart description based on the order of claims.After generating the specification, the webserver 120 transmits thepatent specification with the flowchart description and additionalboilerplate back to the client 110 at step 165. The webserver 120 mayalso transmit any created flowchart drawings or generic drawings at step165.

FIG. 2 illustrates a system 200 that is similar to the system 100, buthas a different architecture. In particular, the system 200 comprises anapplication 210, which may be executing on a client computer, whichcommunicates with the NLP server 230.

The application 210 extracts the text of the method claims and transmitsthe text to the NLP server 230 at step 240. The NLP server 230 processesthe text into NLP tokens at step 250 and returns the text as NLP tokensat step 260 to the application 210. In response to receiving the NLPtokens, the application 210 may generate the specification or part ofthe specification at step 270. The application 210 generates a flowchartbased on the independent claim, generates a flowchart description basedon the order of the claims, and composes apparatus or device claims fromthe method claims.

As noted above, the system 100 or system 200 may also compose additionalclaims from the method claims. In more detail, the system 100 or system200 converts a method claim, which has gerund verbs, into a device orsystem claim, which has present tense verbs. However, in each case, thesystem 100 or system 200 will only provide generic structure (e.g., aprocessor, a memory, a display). The system 100 or system 200 may alsogenerate “means” claims by changing the preamble and adding “means for”before the root gerund verb.

FIG. 3 illustrates a system to extract phrases of a claim irrespectiveof the statutory type (e.g., method, apparatus, etc.) of the claim. FIG.4 illustrate methods executed by an device of the system to extractphrases irrespective of the statutory type of the claim. FIGS. 5A to 5Eillustrate various examples of claims and phrases identified from theclaims by using the methods disclosed in FIG. 4 . FIG. 7 illustrates anexample graph that can be built using subject/context of an apparatusclaim. FIG. 8 illustrates a method that an example application canexecute to build specification descriptions using an apparatus claim.FIGS. 9 to 11 depict various examples of user interfaces of anapplication for building specification descriptions using an apparatusclaim. FIGS. 12 and 13 illustrate various systems that can implement thedisclosed technology. The disclosure now turns to FIG. 3 to illustrate asystem for creating standardized documents from a set of inputs.

FIG. 3 illustrates a sequence diagram of an example system 300 fordynamically generating standardized documents using NLP and a dynamicuser interface. For example, the documents can be a document forsubmission to an administrative agency based on that administrativeagency's procedural requirements. The disclosed system can be applied toany type of standardized document that has a structure that may benefitfrom visually organizing concepts to form complex relationships frominput text.

In the context of a patent application, the system 300 provides animproved NLP analysis method to extract phrases of a claim irrespectiveof the statutory type (e.g., method, apparatus, etc.). The system 300comprises a client 302, a server 304, and an NLP server 306. In someexamples, the server 304 and NLP server 306 can be different serverprocesses executing on the same hardware or configured virtual machine.If the NLP server 306 is hosted locally on the same server as the server304, the NLP engine may be based on a local NLP engine such as naturallanguage toolkit (NLTK), Stanford CoreNLP, etc. However, the NLP server306 may also be a third-party server such as Google Natural Language,Microsoft Cognitive Services, or Amazon Comprehend.

As an example, a virtual machine can execute a webserver in a reverseproxy configuration, which parses the requested uniform resourceidentifier (URI) and directs the request to the server 304 or NLP server306 based on the URI. For example, any URI beginning with “/nlp” (e.g.,“/nlp/document”, “/nlp/phrases”, etc.) is forwarded to the NLP serverexecuting on port 9000. Any other URI is forwarded to the server 304executing on port 6000. In another example, the functionality providedby the server 304 may be performed based on an application executing onthe client 302 (e.g., an Electron application, a React Native Desktopapplication, etc.) that includes local libraries and can directly accessthe file system of the client 302.

In this example, the client 302 receives an application from the server304 at step 308. For example, the application may be a component objectmodel (COM) plugin application that executes within another application(e.g., Microsoft Word®), a stand-alone application that nativelyexecutes as an application (e.g., a Windows® Presentation Foundation(WPF) application, etc.), or a hosted application that uses anotherapplication such as a web browser to render the user interface (e.g.,React Native, React Native Desktop, Electron JS, Blazor WebWindow, .netMAUI, etc.). In some examples, the application can be a web application(e.g., a Microsoft 365® add-in) that is sideloaded into a localapplication (e.g., Microsoft Word) or a web application (e.g., Microsoft365®) and uses an application programming interface (API) to performfunctions.

The client 302 may execute the application at step 310. As noted above,the application may be executed within a browser's sandbox. However, theapplication may also be an add-in that executes within anotherapplication such as a React-based add-in that is executed withinMicrosoft Word® and can use various APIs to interact with the documentand the application. In the example illustrated in FIG. 3 , the system300 is presumed to execute in a browser sandbox and any descriptions inFIG. 3 may be modified or changed based on the execution environment ofthe application.

At step 312, the application transmits the document including at leastone claim to the server. As noted above, FIG. 3 may be modified based onthe execution environment. As an example, if the application is a Reactadd-in that is executing within Microsoft Word, at step 312 theapplication may, using an API available via the application (Office.js,etc.), retrieve the text corresponding to the claims and transmit thetext to the NLP server 306.

After receiving the document, the server 304 extracts text from theclaims at step 314 and transmits text from the claims at step 316 to theNLP server 306. For example, the claim generally is separated by linebreaks and may include whitespace (e.g., spaces, tabs, line breaks,etc.) to illustrate relationships that matter in the claims. Themargins, indents, and other paragraph properties can also be used toidentify relationships in the claims. Accordingly, identificationinformation of the claim is also extracted and transmitted to the NLPserver at step 316. For example, the identification information may bethe claim number and claim line encoded into a unique value, and thetext may be transmitted as a key-value pair at step 316. The NLP server306 processes the text into NLP tokens at step 318 and transmits thetokens and token identification information to the server at step 320.The NLP server 306 generates token identification information toindicate a position of the token in the input text and to identify tokenrelationships based on the various token properties (e.g., dependencylabel, part of speech, etc.).

At step 322, the server 304 extracts phrases and subjects of the phrasesfrom the tokens. In some instances, the phrases do not have a subject(e.g., the phrase is a gerund verb in a method claim and the subject isthe preamble of the claim) or a subject for the sentence can be providedbased on a context of the phrase. The phrases may be extracted based onthe identification of grammar features that link complete phrases suchas adpositional phrases (e.g., “after receiving the message”, etc.) andconjunctions (e.g., “receiving, processing, and storing”) that can beused to form a complete sentence. For example, an adpositional phrasecannot be used to create a sentence because it provides context toanother phrase. In some examples, the server 304 may need to reprocessphrases outside of the context of the region at step 324 to identify thephrases. In some aspects, the server 304 may create a data structure forsending the phrases to the client 302 for efficient transmission. Inparticular, because the tokens have a large amount of data, thetransmission of all tokens using JavaScript object notation (JSON)structures can consume significant bandwidth due to the number ofproperties that must be explicitly identified. An example data structureof a single paragraph in extensible markup language (XML) format isillustrated in Table 2 that can configure the various sentences usingdifferent types of spans that identify the different phrases of theparagraph. The paragraph in Table 2 is further illustrated in FIG. 5A.

TABLE 2 <p>  <descriptiveSpan subject=“filter circuit” context=“feedback circuit”    sentencePreamble=“The feedback circuit ”>   afilter circuit on a path that connects the output terminal of the  replica transistor to a base or a gate of the bias transistor via the  current mirror circuit and the control path  </descriptiveSpan> <span>, </span>  <functionalSpan subject=“filter circuit” context=“feedback circuit”    asPresent=“the filter circuit attenuates afrequency component of    a fundamental wave of the input signal and afrequency component    of a modulated wave of the input signal”asPast=“the first circuit    attenuated a frequency component of afundamental wave of the    input signal and a frequency component of amodulated wave of the    input signal”>   the filter circuit beingconfigured to attenuate a frequency component   of a fundamental wave ofthe input signal and a frequency component of a   modulated wave of theinput signal  </functionalSpan>  <span>, and wherein </span> <descriptiveSpan subject=“filter circuit” context =“feedback circuit”   sentencePreamble=“In some examples, ”>   the base voltage or the gatevoltage of the bias transistor is   controlled in accordance with acurrent flowing in the control path  </descriptiveSpan>  <span>.</span></p>

The phrases 326 from the claims are generated by the server and thensent to the client 302. In some aspects, the phrases can be configuredat the client 302. For example, if the client 302 is a desktopapplication (.net MAUI, Electron, Tauri, React Native Desktop) that doesnot execute in a sandbox, the desktop application may perform thesefunctions.

In some cases, the subject of the sentence is not the subject of thephrase because a context of the phrase, which can be determined based onwhitespace, linebreaks, and other formatting, may impute a subject. Tothis end, a “context” may be detected from previous phrases and a“subject” may be identified in the current phrase. For example, aprevious phrase could be a linking phrase such as “the feedback circuitincludes:” which is followed by a whitespace or formatting to indicatethat the following items are integral to or part of the parent item(e.g., “the feedback circuit”). Based on the context and the subject,the phrase can be converted into a complete sentence.

The identification of different types of phrases is challenging and maynot always be correct because the NLP may not handle some aspects ofgrammar and the meaning of some words. The NLP understands therelationship of the words, but cannot understand their meaning, andwords may sometimes have multiple meanings and forms. For example,“scheduling” is a gerund verb, but “scheduling information” is a noun.To address this issue, the application may include a user interface topermit a user to request analysis of a phrase from the claims or a newphrase (e.g., a phrase not in the claims) at block 328. In some aspects,the user can select the text using a cursor and right-click to select anew analysis of the phrase based on a type determined by the user. Forexample, the contextual menu displays two options to analyze thehighlighted text as a descriptive phrase or a functional phrase. Inother examples, the user interface may display an option to input textand allow the user to analyze the new text based on additional input(e.g., a context, a subject).

Creating a new phrase independent of its context can lead to incorrectresults because the subject of the phrase can have a context that maynot be input. In some cases, the selected text and parts of the claim330 can be identified and transmitted to the server 304, which forwardsthe selected text and parts of the claim 330 to the NLP server 306 forprocessing at block 332. The NLP server 304 returns tokens 334 to theserver 304 and, at block 336, the server 304 generates a phrase 338associated with the user request based on the tokens 336 and theselected text and parts of the claim 330. After the creation of the newor modified phrase, the user may perform input into the application tosequence a patent application together. For example, the user may use aflowchart user interface to sequence a method together and theapplication can create a specification based on that flowchart userinterface.

In some aspects, the application may be configured to create drawings ora specification at block 340 based on the phrases and associated data(e.g., subject and context). In some aspects, the drawings orspecification can be created at the client 302 using the application orthe client 302 can request the server 304 to create the application.

In the example illustrated in FIG. 3 , an improved NLP analysis methodis described that allows the processing of both method and apparatusclaims. By allowing input of method or apparatus claims andidentification of structure (descriptive phrases) and functions(functional phrases), common types of claims can be converted intosentences. This allows applications to be developed to create patentspecifications from apparatus claims, which has been impossible becauseof the large variety of variation in these claims types. In some cases,the understanding of the different types of phrases can also be used totrain machine learning (ML) models to perform similar functions. In somecases, the disclosed methods and processes, which are further disclosedherein with reference to FIG. 4 , can be used for training an ML model.In some other cases, the disclosed methods and processes can be used topreprocess text for input into an ML model to identify the differentphrase types. FIGS. 5A to 5E illustrate various results of processingdifferent claims based on the disclosed methods and processes.

FIG. 4 illustrates an example method 400 for analyzing claims forgenerating descriptions for a patent application irrespective of thestatutory type (e.g., method or apparatus claim). Although examplemethod 400 depicts a particular sequence of operations, the sequence maybe altered without departing from the scope of the present disclosure.For example, some of the operations depicted may be performed inparallel or in a different sequence that does not materially affect thefunction of method 400. In other examples, different components of anexample device or system that implements the method 400 may performfunctions at substantially the same time or in a specific sequence.

According to some examples, method 400 includes receiving a claim to beincluded in a patent application at block 402. For example, anapplication that is executing on a processor 1205 illustrated in FIG. 12may receive a claim to be included in a patent application.

According to some examples, method 400 includes separating (e.g., by theprocessor 1205) the claim into a plurality of regions based on abreakpoint at block 404. The text can be in different forms such as aword document, a hypertext markup language (HTML) element, or text, andthe text can be used to separate different regions and identifyrelationships using line breaks, paragraph elements (e.g., <w:p>elements in a word .docx file, etc.).

According to some examples, method 400 may analyze text associated witheach region using a natural language processor at block 406. Forexample, the application may send the text to a natural languageprocessor for analysis of each token in the text of that region. A tokencan be a word, punctuation, or a part of words (e.g., hyphenated wordssuch as processor-based, etc.). In some examples, the regions correspondto a new line of the text, or a particular element (e.g., paragraphelements).

According to some examples, method 400 includes identifying (e.g., bythe processor 1205) at least one phrase within each region at block 408.For example, the processor 1205, illustrated in FIG. 12 (or theprocessor 1310), may identify at least one phrase within each region.The phrases can be identified based on, for example, identifying tokensin results of the natural language processor that are immaterial tocreating sentences from the claim. For example, a claim includes anumber of text items that are immaterial for creating language, such asa preamble of a dependent claim, or punctuation at the end of a line. Insome cases, a “wherein” or a “whereby” clause can be deemed immaterial.After identifying immaterial tokens, method 400 separates the regioninto groups of words based on punctuation in the region. In some cases,punctuation can be part of a single phrase (e.g., conjunction) or canseparate phrases.

According to some examples, block 408 may further include analyzing eachgroup of words using the natural language processor. For example, eachphrase can be analyzed to determine if the group of words includesinformation that would be sufficient to form an entire sentence. Basedon the analysis of each group of words, block 408 can determine whetherto merge any group of words. For example, adpositional phrases (e.g.,“in response to receiving the message” and “upon detection of theperson”) and conjunctional phrases can be identified and linked to acorresponding phrase (e.g., “in response to receiving the message,sending a response” and “upon detection of the person, activating analarm”) that can be converted into a complete sentence.

According to some examples, method 400 includes determining (e.g., bythe processor 1205) a type of the at least one phrase. In some aspects,the type of phrase includes a functional phrase or a descriptive phraseat block 410. As noted above, a functional phrase identifies a functionthat is performed, and the descriptive phrase may describe aconfiguration such as an object being connected to another object, adevice integral to another object, and the like.

When the root token corresponds to the noun, the type of the at leastone phrase may correspond to the descriptive phrase, and, when the roottoken corresponds to the verb, the type of the at least one phrase maycorrespond to the functional phrase. However, the possibility of beingaccurate is insufficient, and using a root verb approach will yieldincorrect detection because each phrase is different, each client hasdifferent preferences, and each attorney responsible for the claim hasdifferent preferences. For example, some claims may lead with whatappears to be a gerund verb that may be incorrectly identified as a rootverb but is incorrect based on the language style. For example, anadpositional phrase can include a gerund verb, but the root of thelanguage can be a noun (e.g., “after receiving the message, theprocessor processes the message”). Examples of different phrasesprocessed according to the instant disclosure are illustrated in FIGS.5A to 5E.

According to some examples, method 400 includes, if the claim isindependent, determining a statutory category of the claim at block 412.In some examples, determining a statutory category of the claim can bebased on types of phrases. For example, if a first phrase of a claimrecitation is a descriptive phrase, the statutory category is anapparatus (or system) claim. If the first phrase of a claim recitationis a functional phrase (e.g., functional), the statutory category is amethod claim. In some aspects, in the event a claim is determined to bean apparatus or system (e.g., based on the first phrase or based on astatutory category of a parent claim that a dependent claim dependsfrom), block 412 can include generating a method claim based on thephrases in the claim. In some aspects, the generation of the methodclaim can occur after various user inputs for creating the patentapplication.

In further aspects of block 412, method 400 may include determining astatutory category of the claim based on a first noun in the claim. Thestatutory category may comprise a method claim based on the first nounincluding a keyword and the statutory category comprises an apparatusbased on the first noun not including the keyword. For example, if thefirst noun in the claim is determined to be similar to a method, theclaim is determined to be a method claim.

Method 400 may further include receiving input to modify a phrase of theclaim at block 414. In some aspects, the descriptive phrase can beincorrect because a word can have multiple meanings and the phrase mayreasonably correspond to both a descriptive and a functional language.Accordingly, a user interface may be implemented that allows a user toremove phrases and create new phrases, as described above with referenceto FIG. 3 .

In one example of block 414, method 400 can receive an input to deletean incorrectly identified phrase. For example, a user can select adelete option 510 illustrated in FIG. 5A to remove the identifiedphrase. After removing the identified phrase, the user may create textfor a revised phrase based on the user interface. For example, the usercan use a cursor and select text in the claim (which limits the text theuser can create), or the user can insert text into a user interface forcreating entirely new phrases that do not exist in the claims. Inresponse to the new text, the user can submit a request to analyze thetext. In some aspects, the request can specify a type of phrase toenforce a particular type of analysis of the claim language. In someaspects, important aspects of the phrase can be omitted from this text,and the user interface can be configured to send a portion of the claimto allow the server to understand the context of the phrase andcorrectly generate a sentence based on the modified phrase. For example,the phrase can be functional but can be linked to a structure.Accordingly, if the user requests analysis, the user interface canensure that the appropriate information is sent with the new phrase toallow the processing to correctly identify structures relevant togenerating the sentence. For example, if the phrase is “configured tostore information,” the appropriate context of the phrase is importantbecause a subject cannot be extracted from that phrase itself.

According to some examples, method 400 includes creating text for the atleast one phrase to be used in a complete sentence based on the type ofthe at least one phrase at block 416. For example, the processor 1205illustrated in FIG. 12 may create text for the at least one phrase to beused in a complete sentence based on the type of the at least onephrase.

FIGS. 5A to 5E are various example claims that are analyzed based on thedisclosed methods to illustrate identification of descriptive phrases,functional phrases, and linking phrases, in accordance with someexamples. In each illustration, a region including square corners (e.g.,reference numeral 505) indicates a descriptive phrase, and a regionincluding rounded corners (e.g., reference numeral 515) indicates afunctional phrase. A region including a dashed border illustrates alinking phrase.

FIG. 5A illustrates an example of a user interface that displays aresult of an analysis of a filter circuit recitation from an apparatusclaim, in accordance with some examples. The filter circuit provides agood example because it includes both structure and function within asingle region, which is extracted based on linebreaks or differentparagraph elements in an OpenXML document (e.g., <w:p> elements). Thefirst phrase 505 is descriptive because it describes an electricalconfiguration of the first circuit. The first phrase also includes adelete option 510 to delete the phrase and allow a user to select andidentify specific phrase types. A second phrase 515 is a functionalphrase because it describes a function of the filter circuit(attenuating a frequency component). A third phrase 520 is based on awherein phrase and is determined to be a descriptive phrase, but in somecases could be deemed to be a function. However, the third phrase 520 isdescriptive of the base or gate voltage and does not identify a functionof the filter circuit. The third phrase 520 also illustrates an exampleof subject and context. In particular, the subject of the sentence isthe filter circuit. However, the subject of the third phrase is the basevoltage or the gate voltage. In this case, the subject of the phrase canbe mapped to the prior phrases and the sentence for the third phrase 520can be generated based on the subject of the first phrase. In this case,the third phrase can be mapped to a transitional phrase.

FIG. 5B illustrates an example of a user interface that displays aresult of an analysis of an independent method claim, in accordance withsome examples. In particular, FIG. 5B illustrates the analysis of claim1 of the instant application and each of the recitations, except phrase525, are functional phrases. The phrase 525 is descriptive and furtherdefines the type of phrase, and no keyword or trigger language (e.g.,wherein, whereby) indicates that the phrase 525 is descriptive.

FIG. 5C illustrates an example of a user interface that displays aresult of an analysis of a dependent apparatus claim, in accordance withsome examples. The dependent apparatus claim in FIG. 5C includes alinking phrase 530 that is deemed immaterial, a descriptive phrase 535,and a functional phrase 540. In this example, the functional phrase doesnot include a subject, and the method is capable of identification ofthe functional phrase without any subject. In this case, the context ofthe functional phrase can be used to identify the subject, which can beextracted from phrase 535 to form a complete sentence.

FIG. 5D illustrates an example of a user interface that displays aresult of an analysis of a dependent apparatus claim without anyfunction, in accordance with some examples. In some examples, the phrase545 may be incorrectly detected because the object of the verb(comprises) is present. Accordingly, a user can delete the phrase 545 tocorrect this issue.

FIG. 5E illustrates an example of a user interface that displays aresult of an analysis of a dependent apparatus claim with a complexseries of conjunctions, in accordance with some examples. In particular,this example illustrates that conjunctions can The first phrase 550 canbe used to form a sentence based on the context, which can be identifiedin the preamble of the claim, and the second phrase 555 can bereconfigured into a complete sentence, despite the complexity of thelanguage.

FIG. 6 illustrates a conceptual diagram illustrating a method toidentify a context and a subject of different lines of the claim inaccordance with some aspects. In particular, FIG. 6 illustrates anexample claim 600 that includes a mixture of structure and function thatcan be separated into functional and descriptive phrases as describedabove. Unlike a method claim, an apparatus claim can have differentstructures that have relationships with each other and the formation oflanguage based on the claims should consider the context of a line ofclaim, whether the line includes a subject, and whether the line has arelationship with a prior line. In some aspects, a line of a claim isseparated by a suitable linebreak as illustrated by the pilcrow symbol(¶).

The method of identifying a context and a subject will generally consistof a queue with three lines including a current line, a previous line,and a next line. The queue will be populated during the iteration ofeach line and build a dictionary that identifies previously identifiedsubjects of a line, and a context stack that identifies a currentposition within a graph. For example, the method would identify apreamble that provides a root context 602 or can be the subject of anysentence when iterating over an independent claim. The root context 602would be added to the context stack. As the method iterates over thenext line, the method can determine that a subject 604 of the linebegins with a functional phrase or a descriptive phrase that includes asubject. The line including subject 604 has a single phrase (“anamplifier configured to amplify and input signal”), the method cangenerate a sentence based on the root context 602. Specifically, theroot context can be modified to include a reference label, if available,and conjugate the phrases based on the type of phrase (e.g., “the poweramplifier 600 includes an amplifier transistor configured to amplify aninput”).

Similarly, lines that begin with subject 606 and subject 608 aresiblings of subject 604 and the method configures a sentence with theroot context 602. If any of the lines include an additional phrase thatwas separate from the leading phrase, the subject of the additionalphrases is identified from the subject of the line. For example, theline leading with subject 610 includes a second descriptive phrase (“thebase voltage or the gate voltage is reverse biased”) that furtherdescribes the feedback circuit. The method can use the subject 610 andthe NLP of the phrase to generate a sentence by, for example, insertinga preposition into the phrase (e.g., “the bias voltage or gate voltageof the feedback circuit is reverse biased”). As described above, thesubjects are placed into a dictionary or a hash that uniquely identifiesan object. For example, in a hash of string types (e.g.,Hashset<string>), each value in the hash corresponds to a unique stringvalue that corresponds to the subject.

The next line includes a wherein clause with the root tokencorresponding to subject 612. The method can recognize the subject 612and identify that the subject 612 has been identified in the hash. Adictionary is different from a hash and includes a key-value pair (e.g.,Dictionary<string, Boolean>). In this aspect, the method can identifythat the line comprises a linking phrase and ends with an opentransition (e.g., the trailing colon). In response to detecting thelinking phrase, the method adds the identified subject 612 to thecontext stack. The method can continue iterating through the variouslines, but can now build the sentence based on the identified context orsubject (e.g., “the feedback circuit includes a control path, a replicatransistor, a current mirror, and a filter circuit.”). In some cases,the claim term may be different that the description of thecorresponding item or the drawing may identify the object differently,as illustrated herein with reference to FIG. 9 . The method cantherefore use related terms to generically describe the structure orspecific terms and then provide a generic example. For example, thefilter circuit may be described as a low pass filter in the drawings,and the method can use knowledge of alternative language for the claimterm to build a description that links terms (e.g., “The feedbackcircuit includes a filter circuit, such as low pass filter 300, on apath that connects the output terminal of the replica transistor to abase or a gate of the bias transistor via the current mirror circuit andthe control path.”).

In some aspects, the method can also use whitespace characters such astabs to imply relationships. For example, the tab character illustratedin the lines having subjects 614, 616, 618, and 620 may imply arelationship with a previous object. In one aspect, the method comprisesevaluating the next line to determine whether the subject of thesentence should be added to the context stack. Similarly, whitespace canalso be used to identify the end of a context such as the end of adescription related to the feedback circuit. Although not illustrated inFIG. 6 , the claim can include further context, such as a description offunctions, or a description of additional structures. For example, acommon claim strategy is to identify a structure with a linking phrasefollowed by a colon (e.g., “a processor configured to:”, and then theimmediate lines following the structure are functional phrases thatidentify the functions performed by the structure. In this illustrativeexample, the method can identify that the functional phrases do notinclude a subject and therefore use the last item in the context stackas the subject of the sentence.

When a context ends, the context stack is popped, which causes the lastitem to be removed. The context stack may not be popped if the contextstack only consists of the root context 602. The identification of acontext and a stack in purely functional programming techniques and is achallenging task because small errors that a person can readilyrecognize are difficult for a machine to understand. For example, thedifference between a tab character and paragraph formatting to applywhitespace can be difficult to write specific instructions for themachine to process. In some aspects, a machine learning (ML) model canbe trained to identify the subject and context associated with thevarious phrases based on text and other metadata such as paragraphformatting. In one aspect, each line illustrated in FIG. 6 correspondsto an OpenXML paragraph object (e.g., <w:p>) and each OpenXML paragraphobject further includes a paragraph properties object (e.g., <w:ppr>)that identifies intending, position, line spacing, margins, etc.

FIG. 7 illustrates a graph 700 illustrating a relationship of variouscontexts and phrases identified in the claim 600 in accordance with someaspects. In one aspect, the root context 602 serves as a root node ofthe graph 700 and all elements associated with the language of the claimare descendants. For example, the root context 602 includes child nodescorresponding to subject 604, subject 606, subject 608, and subject 610.As noted by the legend, the subject 604, subject 606, subject 608, andsubject 610 are descriptive, but the child nodes of the root context 602may also be functional phrases. Each node of the graph 700 can includefurther children, such as subject 610 including children nodes includingsubject 614, subject 616, subject 618, and subject 620. Each node caninclude child nodes such as phrase 630, phrase 632, and phrase 634.

In some aspects, the construction of the graph 700 also includes othersubject matter in the claim, such as dependent claims. The graph 700should include all subject matter recited in the claim, and based on thestructure of the graph 700, the language of the claim can be convertedinto a strict description. In other aspects, the graph 700 can serve asa basis for applying portions of a description in conjunction with auser interface, such as the user interface illustrated in FIGS. 9, 10,and 11 . In one aspect described below, a context of a drawing canunderstood and a description of the apparatus claim can be generatedbased on a combination of the graph 700 and user inputs into a userinterface, thereby allowing a patent application drafter the ability tovisually prepare a patent application that fully supports the claim. Inother aspects, the graph 700 can be used to derive a paragraph forliteral support in some jurisdictions.

FIG. 8 illustrates an example method 800 for visually building aspecification description from an apparatus claim in accordance withsome aspects of the disclosure. Although the example method 800 depictsa particular sequence of operations, the sequence may be altered withoutdeparting from the scope of the present disclosure. For example, some ofthe operations depicted may be performed in parallel or in a differentsequence that does not materially affect the function of the method 800.In other examples, different components of an example device or systemthat implements the method 800 may perform functions at substantiallythe same time or in a specific sequence.

In some aspects, the method 800 can be performed by a computing system(e.g., computing system 1200). For example, the computing system mayreceive instructions from a remote server and configure the computingsystem to generate a patent application based on claim language,drawings, and user input. In some aspects, the method of FIG. 8 ispresumed to have sent the document, a portion of the document, or aportion of the text of the document to a server (e.g., server 1255) forprocessing, and the server has received the results including at leastone phrase as described above. Further, the method of FIG. 8 is presumedto have received drawings associated with the patent application toperform the functions identified below. The drawings can be in anysuitable format and may be converted into a format that is ideal for theidentification of relationships. For example, scalable vector graphic(SVG) files can identify points and relationships after thenormalization of various vectors.

The method 800 includes constructing a graph including a plurality ofnodes associated with at least a portion of phrases from a set of claimsbased on a context and a subject for each phrase of the portion ofphrases at block 802. For example, each phrase of a set of claimscorrespond to a different node in the graph. The graph can be a datastructure that forms hierarchal or graph relationships. For example, thedata structure can be a pure hierarchical structure. In other cases, thegraph can be a graph data structure that identifies nodes and edges thatidentify relationships between the node (e.g., an edge from node A tonode B that identifies a sequence or a parent-child relationship).

At block 804, the method includes displaying (e.g., based oninstructions from the computing system to display associated with acomputing system) a user interface for writing a patent application. Inone aspect, part of the user interface can include a claim panel thatidentifies a state of the claims, for example, whether a phrase of aclaim is associated with a structure in a drawing. For example, at block806, the method 800 includes displaying a claim based on phrases thatare separated based on a phrase variant. As described above, the phrasevariant includes at least one of an adjective phrase and a verb phrase.Non-limiting phrase variants that can also be displayed include alinking phrase, a preamble phrase (e.g., the computer-implemented methodof a claim), and an adpositional phrase.

In one aspect, the computing system can display a user interface thatillustrates relevant content in the document section or the differentdocument, and allows input to identify relationships. For example, claimterms in the document may not necessarily align with extracted text inthe drawings, and reference labels in the drawings may not necessarilybe identified to correspond to text. The user interface allows a user tonormalize the various terms by predictive text inputs, and thenexcluding the data that is assigned to to related data. As illustratedbelow in FIG. 9 , the claim text, the drawing text (if available), and areference label can be different and the user interface enables a userto create relationships to assist in creating text associated with thedrawing. For example, when a sentence is generated based on a phrase,the sentence can be generated with an example that relates a claim termto the drawing.

In one aspect, the computing system inserts at least one metadata nodeinto the graph based on the context of child content. For example, thecomputing system can insert metadata nodes that correspond to structuresto identify regions of description corresponding to that node. The usercan also create metadata nodes. The metadata node defines a collapsibleparent node that provides a context associated with child nodes and canbe used to help a drafter to organize concepts in an efficient manner. Adocument does not represent how a person visually perceives content inthe most efficient manner, but a tree structure and various nodes thatcan hide/display content can allow a user to visually understand thewriting and organization of the document using spatial awareness. Thedraggable tree structure can also simply reorganization and review ofconcepts within a patent specification.

At block 808, a user can drag a phrase associated with a claim tointeract with the user interface. For example, the computing system candetermine that a first phrase of the claim is dragged in the userinterface and dropped into an object of the plurality of objects. In oneexample, the plurality of objects are nodes within a tree view componentbased on a hierarchical relationship or a graph data structure. The treeview component can be configured to drag and drop nodes to convenientlyreorganize parent/child relationships and sequence nodes in a suitableorder.

As an example, a tree view component can represent a specification witha root node that represents the entire patent specification and thefirst nodes of the root correspond to different document sections (e.g.,document description, brief description of the drawings, summary, etc.).In another example, the root node can represent a portion of thedocument such as represent the root node corresponding to contentassociated with a single figure. As will be described later, metadatacan be injected into the document and the root node of the single figurecan encompass all content associated with that drawing, and it would bepossible to extract the entire description corresponding to this figure,including the drawing too, to reincorporate into a later or a relatedapplication. For example, if two drafters are working on a singleapplication in parallel, this user interface feature would allowdrafters to seamlessly merge two different patent applications into asingle patent application with minimal effort and stress.

Based on the user interface input, the method can create (e.g., by acomputing system) and display a first object within the user interfacebased on the first phrase at block 810. For example, the first phrasecan have a subject and a context as described above and the computingsystem generate a tree view node that includes a sentence that can usethe subject or the context to create a sentence associated with thefirst phrase. For example, at block 810, the computing system canconstruct a sentence based on the first phrase, a subject of the firstphrase, and a context associated with the first phrase. In some cases,the context can be injected into a phrase as noted above, or thesentence can be generated without the context (e.g., when the phrasebegins with the subject. Generation of language with apparatus claims isdifferent from method claims because method claims generally do notconsider the organization and structure of the different components. Anapparatus claim can have different structures, and those differentstructures can have sub-structures (e.g., a processor includes a cache).The context and subject are necessary to correctly form a sentence forapparatus claims, but not for method claims.

As will be described below, the user interface in FIG. 9 can identifyrelationships between claim terms and other material. The first objectcan include the identified relationships, such as specifically relatinga claim term to a text description and a reference label within thedrawing. In another example, the first object can include a plainEnglish description example of the claim term.

In some cases, at block 810, the computing system can display a userinterface to edit the sentence. For example, the sentence can be acustom sentence that does not correspond to a claim. In other aspects,the user interface to edit the sentence can be a customized editor(e.g., a content editable block element) that causes a conjugatedversion of the first phrase to be immutable. In other aspects, the userinterface can allow the conjugated version of the first phrase to bemutable.

At block 812, the computing system can convert the plurality of objectsin the user interface into the patent application including contentbased on the plurality of objects within the user interface. Forexample, the computing system can take the various inputs and sequencetogether a plurality of objects into a written description based on thegenerated sentence, as well as custom input sentences. In one aspect,the computing system can insert metadata into a document of the patentapplication that identifies at least one object of the plurality ofobjects in the user interface. In general, it has not been possible toinsert metadata into OpenXML documents because third-party applicationprogramming interfaces (APIs) do not support all features, includingopen-source APIs that are sponsored by vendors such as Microsoft.Unsupported metadata inserted into the document is removed during theXML validation process (e.g., when the document is saved). A custom XMLlibrary has been created to build or modify OpenXML content to supportOpenXML smart tags, which can enable paragraph-based tagging orcontent-based tagging. Paragraph-based tagging is the identification ofcontent at the paragraph level (e.g., an order of the paragraphs).Content-based tagging identifies a range of content in the paragraph andcan, for example, link a phrase in a claim to the language generated forthe document based on that claim. An example of paragraph-based taggingand content-based tagging is illustrated below in Table 3.

In one aspect, the metadata nodes of the graph can be embedded into thedocument itself. At block 814, at a later time (e.g., a week), anapplication can read the document of the patent application and canrestore a state of the plurality of the objects based on the embeddedmetadata. In some cases, block 814 can also include the identificationof changes in the document and mapping those changes into theapplication state. For example, if a phrase is generated based on aclaim and that phrase is detected to be modified (based on the metadataindicating what the phrase should be), the application can alert theuser to the change in text.

Table 3 below illustrates an example paragraph with custom tags andillustrates various types of information that can be embedded into asingle paragraph. For purpose of simplicity, the example paragraph omitssome tags (e.g., the text <w:t> tag) and attributes in an OpenXMLdocument for clarity. In Table 3, the paragraph can include metadatathat identifies a paragraph number of the paragraph and a uniqueidentifier, a linked previous neighbor paragraphs, a related figure, aclaim source (e.g., claim 1), and so forth. Further, the paragraph caninclude runs (<w:r>, which can also be referred to as spans) of text andthe runs can identify a phrase of that paragraph. When the method viewsthe paragraph in Table 2, the method can determine that the childcontent (e.g., within the tags) and the attribute that the method embedsin the custom tag are different. In this aspect, the patent-specificapplication can therefore determine that the text was edited, and therelated paragraphs that are identified in the custom tag's attributesshould be updated.

TABLE 3 <w:p>  <w:smartXml>   <w:smartXmlPr>    <w:attr w: paragraphicIdw:val=“100”/>    <w:attr w:Id w:val=“AJi1a-1mUf1”/>    <w:attrw:nextParagraphId w:val=“lkk1j-00091”/>    <w:attr w:prevParagraphIUdw:val=“m5YH1-POnb1”/>    <w:attr w:relatedFigureId w:val=“5”/>   <w:attr w:claimId w:val=“1”/>   </w:smartXmlPr>  <w:smartXml> <w:r>In one example, the computing device may </w:r>  <w:smartXmlphrase=“receive a network route from the PCE” claimSource=“1”,  phraseld=“kd81d-24akO” relatedParagraph=“XXXXX-XXXXX”  relatedParagraph=“XXXXX-XXXXX” relatedParagraph=“XXXXX-XXXXX”  relatedParagraph=“XXXXX-XXXXX”>   <w:r>receive a network route from anetwork controller</w:r>  </w:smartXml>  <w:r>. For example, the SDNcontroller can be configured to provide this   message. </w:r> </w:p>

In this example, the first custom tag includes a property tag(<w:smartXmlPr>) with attributes, and the second custom tag includesattributes within the tag itself. In some aspects, an attribute of thefirst tag may be different and more complicated such as Javascriptobject notation (JSON) that describes a complex object and the JSONobject can be encoded via a base64 value into a single attribute. Thismay simplify serialization and deserialization based on the type ofapplication. The first custom tag includes a phrase that identifies theoriginal text of the phrase, and if the run content (e.g., <w:r>changes, the custom tag can flag an issue. In some cases, this can beused to promulgate a later change in a claim to fix a typographicalerror for example. The custom tag can also include a phrase identifierthat maps to the original phrase in the claim, and can include otherinformation such as related paragraphs that include the content.Non-limiting examples of usage of the phrase in a patent applicationinclude, for example, a description of a flowchart, a node/treestructure, a description in a block diagram, a summary of theapplication, an abstract, a claim (e.g., as part of an apparatus claim),or a multiple-dependency style of claims for literal support in somejurisdictions.

In some cases, the method can also insert global information into thedocument itself. For example, an openXML document accepts a custom XMLpart that can be used to link content controls another other material(e.g., a mail merge, etc.) of the document. For example, the method caninclude a custom XML part that may be loaded with relevant static datasuch as the claims, paragraph information, etc. When the document isreturned to the method, the method can perform several analyses toidentify relevant changes such as deleted paragraphs, revised claims,etc. The custom XML part applies to a global state of the document andthe custom tags apply to instances or the rendered content. That is, thecustom tags apply to content inline and identify, for example, how aspecific portion of text corresponds to a portion of a claim.

FIG. 9 illustrates a function of an application 900 for normalizingclaim terms with various content within a drawing in accordance withsome aspects of the disclosure. In particular, FIG. 9 illustrates anapplication 900 (e.g., a web application, a native desktop application,etc.) executing software instructions to create a user interface havinga drawing region 902 and a term region 904. The drawing region 902includes a plurality of objects and includes reference labels. Forpurposes of illustration, reference labels beginning with X (e.g.measurement system X10) is referring to a proposed illustration toillustrate a drawing being used within the application 900, andreference labels beginning with numerals (e.g., drawing region 902) arereferring to features of the application 900.

In some aspects, the application can analyze the drawings to extracttext such as the reference labels (e.g., X20, feedback circuit X30). Insome cases, some text may only be reference labels, such as X32, whichcorresponds to a feedback path, and X20. This is a particularly commonfeature in mechanical and circuit drawings that use symbols and shapesto identify meanings. In the event both can be extracted, as illustratedin the term region 904, the application can separate the drawing textfrom the reference label (e.g. using a regular expression). In otheraspects, the text may be underlined and the application can extractunderlined text in some cases. However, even if text is identified, thetext within the drawing does not necessarily correspond to the claims,which are typically more generic or require a specific word to trigger asuitable interpretation. In some cases, the terms can simply bedifferent by accident (e.g., measuring circuit and measurement system).

Similarly, the application or a server (or both) can merge noun chunksto create a compound noun (e.g., a first device, at least one memory,scheduling information, etc.). Based on the identified claim text, theapplication may perform a whole match or a partial match to determine alogical similarity. For example, the application could compute theLevenstein distance of the claim text and the drawing text to identify asimilarity of the two words. In another aspect, the applicant may sendthe terms to the server, which may execute an NLP server, and compute asimilarity of the words or use semantic similarity (e.g., word2vec) toidentify differences in the whole word or different words. For example,a similarity comparison of a measuring circuit and a measurement systemmay be identified and the application can automatically relate languagein the drawing to language in the claim text.

For terms that do not have any linked text, the application may performa search to identify a related line based on identifying a boundary 906and the application may search for lines (e.g., straight lines, Beziercurves, etc.) that start or end within the boundary region. In thisillustrative example, a line 908 includes an endpoint within boundary906, which indicates to the application that the line may be associatedwith some other text. Based on the identification of the line 908, theapplication can identify an endpoint of the line 908, and then identifyshapes that the line 908 is proximate to, intersects, or contacts. Forexample, the application may generate a bounding region 910 for eachshape and may execute a raycasting algorithm to determine if theendpoint of the line 908 is within the bounding region 910. If the linefalls within this bounding region 910, the application can associate thereference label with any subject matter. However, in the illustrativeexample, the amplifier is a corresponding circuit shape and does notinclude any text. In this example, the reference label can be linked toregions that include text.

In some aspects, the application may also identify shapes within shapesto identify a parent-child relationship, if that relationship has noalready been formed. For example, the measurement system X10 can includedetector X11, coupler X12, and component X13. The application mayidentify the relationship between detector X11, coupler X12, andcomponent X13 as children of the measurement system.

Another method of identifying relationships includes identifying a linethat connects a shape to another shape. For example, the line 912 canconnect the amplifier X20 to the feedback circuit X30. Similar to theabove, the line can be analyzed to determine if the point is within aboundary region (e.g., boundary region 910). In some cases, because theendpoints are reflected as float values (e.g., decimals), the values maynot be precise, and implementing a boundary region can ensure thatconnected components are identified. Based on the above-describedtechniques, the drawings and the claims can be synthesized using theapplication 900. In one case, the application attempts to synthesizeinformation based on value equality, such as the claim term feedbackcircuit corresponding to the text in the drawing, and NLP processing. Insome cases, the empty cells in the drawing region 902 can be populatedbased on the unused language associated with the corresponding text. Ifdrawing text is assigned to claim text, then the drawing text and claimtext will be used to populate a dropdown list. Relationships cancross-correlate and, in response to correlating two different terms, thedrawing region 902 can dynamically merge rows based on creating therelationship between the two terms.

In other cases, a user may enter the various terms through the userinterface and manually align the content. Although this may be a tediousprocess, the manual entry of text that corresponds to a reference labelcan assist in creating various mechanisms to reduce text input such as ashortcut. For example, a document generated by the application may beable to inject a shortcut into the document and the word processingapplication may dynamically replace these shortcuts while editing thatdocument.

FIG. 10 illustrates a function of an application 1000 using phrases tovisually prepare a description associated with an apparatus claim inaccordance some aspects of the disclosure. In particular, theapplication includes a drawing region 1002 and a claim panel 1004. Theclaim panel 1004 may demarcate the claims to indicate different phrases,such as functional phrases, descriptive phrases, and so forth. The colorof the phrase in the claim panel 1004 indicates whether the claim termis assigned to a structure. For example, FIG. 9 illustrates that a userdrags the phrase 1006 along path 1008 to place the phrase 1006 over arelated structure in the drawing region 1002 (e.g., the detector X11).At this point, the user can drop the phrase 1006 into the component inthe drawing region to assign the phrase 1006 to the component.

In some cases, the application 1000 may display phrases assigned to thecomponent in a popup window 1010 to provide feedback to the user.Feedback is important because it provides a mechanism for the user tounderstand the state. In some cases, the phrases may be modified toindicate a link to the corresponding component, such as a labelcorresponding to the component in the drawing. In another aspect, a usermay hover a cursor (mouseover event) over a phrase in the claim panel1004 and the application may highlight the component that the phrase isassigned to in the drawing region 1002.

FIG. 11 illustrates another function of an application 1100 that usesintuitive input to visually prepare, organize, and draft an applicationusing apparatus claims in accordance with some aspects. In some cases,the application includes a plurality of objects such as nodes in a treeview component 1102. A tree view component is a tree or hierarchicaldata control that visually arranges content based on a parent/childrelationship. In some cases, the tree view component includes a rootcomponent that encompasses the whole. For example, a tree view componentcan represent an entire specification or can represent a single drawing.

The user interface illustrated in FIG. 10 is one example of a method tolink phrases of an apparatus claims, and the user interface in FIGS. 9and 10 can be used to create the graph (or hierarchical data) used topopulate the tree view component 1102. In other aspects, the tree viewcomponent 1102 may be populated using only the claims and asubject/context analysis.

In some cases, when populating the data structure (e.g., graph) for thetree view component 1102, the application may insert metadata nodes thatidentify a logical concept and abstract different parts of thedescription. For example, the tree view component 1102 includes metadatanodes 1104 that logically represent different sections of the apparatusdrawing, such as the feedback circuit X30 and the measurement systemX10. As illustrated in FIG. 11 , the tree view component 1102 candisplay a sentence 1106 that is generated from the phrase and a contextor subject. For example, the tree view component 1102 can provide thecontext and subject relationships.

In this user interface, the user may be able to restructure thedescription based on drag and drop operations. The drag and drop allowthe hierarchical organization and a logical presentation of sentences,as well as a simplify the review of content that will be inserted intothe specification. Patent specifications can be significantly long andwieldy documents, and a tree view component can assist in scoping theview to relevant material into manageable portions and enable faster,simpler, and quicker organization. In some cases, the user interface caninclude multiple drawings and allow the user to move the figures withrespect to each other. In the event a figure is moved, the correspondingtext is updated, including reference labels and references in othersections to those reference labels.

Metadata nodes can also be custom-created, which can be beneficial fortraining new drafters. For example, a reviewer of the patentspecification can create metadata nodes that visually illustratefeedback and provide context. This feature can be beneficial forbifurcated drafting, such as an attorney may draft the claims of thespecification and and a structural outline, and then another third-partydrafting service writes the remaining specification based on theattorney outline.

The tree view component can also include a linebreak node 1110 with apilcrow mark indicating that a new paragraph in the patent specificationwill be inserted at the end of a particular node. In some cases,although the linebreak node 1110 is smaller, it is not associated withany text and can be customized to provide a clear visual illustration ofhow the patent application is flow when converted to conventionalwriting.

FIG. 11 provides a functionally different drafting mechanism that useslogical and hierarchy to organize concepts. As a result, a patentspecification drafter is able to navigate and understand theorganization and flow without reading paragraphs of content tounderstand the position in the patent specification. The drag and dropoperation enables rapid and accurate modifications while reducing errorsand reducing stress.

In some cases, the nodes may also be edited. For example, the content inthe nodes can be a content editable block element. In other aspects, acustomizable editor may be implemented to allow modification of contentaround the conjugated phrase to provide, for example, a more smoothtransition or an explanation. However, the conjugated phrase may beimmutable to maintain the link between the claims and the specification.

Other aspects of the application include embedding relevant metadatainto the generated patent specification. For example, the metadata nodescan be inserted into the OpenXML that identify an application state, andwhen the document is returned to the application 1100 (e.g., after aninventor edits the application in a different application such as a wordprocessing application), the document state can at least be partiallyrestored to allow a drafter to continue editing the patentspecification.

Although a variety of examples and other information was used to explainaspects within the scope of the appended claims, no limitation of theclaims should be implied based on particular features or arrangements insuch examples, as one of ordinary skill would be able to use theseexamples to derive a wide variety of implementations. Further andalthough some subject matter may have been described in languagespecific to examples of structural features and/or method steps, it isto be understood that the subject matter defined in the appended claimsis not necessarily limited to these described features or acts. Forexample, such functionality can be distributed differently or performedin components other than those identified herein. Rather, the describedfeatures and steps are disclosed as examples of components of systemsand methods within the scope of the appended claims. Moreover, claimlanguage reciting “at least one of” a set indicates that one member ofthe set or multiple members of the set satisfy the claim.

FIG. 12 illustrates an example computer system 1200 for executing clientor server operations, in accordance with some examples. For example, theexample computer system 1200 may execute a client application, aserver-side application for performing the instant disclosure, or an NLPengine.

The example computer system 1200 includes a processor 1205, a memory1210, a graphical device 1215, a network device 1220, interface 1225,and a storage device 1230 that communicate and operate via a connection1235. The connection 1235 can be a physical connection via a bus, or adirect connection into processor 1205, such as in a chipsetarchitecture. The connection 1235 can also be a virtual connection,networked connection, or logical connection.

The processor 1205 reads machine instructions (e.g., reduced instructionset (RISC), complex instruction set (CISC), etc.) that are loaded intothe memory 1210 via a bootstrapping process and executes an operatingsystem for executing applications within frameworks provided by theoperating system. That is, the processor 1205 can include anygeneral-purpose processor and a hardware service or software service,which are stored in memory 1210, and configured to control processor1205 as well as a special-purpose processor where software instructionsare incorporated into the actual processor design. The processor 1205may essentially be a completely self-contained computing system,containing multiple cores or processors, a bus, memory controller,cache, etc. A multi-core processor may be symmetric or asymmetric.

For example, the processor 1205 may execute an application that executesan application provided by a graphical framework such as Winform, WPF,Windows User Interface (WinUl), or a cross-platform user interface suchas Xamarin or QT. In other examples, the processor 1205 may execute anapplication that is written for a sandbox environment such as a webbrowser.

The processor 1205 controls the memory 1210 to store instructions, userdata, operating system content, and other content that cannot be storedwithin the processor 1205 internally (e.g., within the various caches).The processor 1205 may also control a graphical device 1215 (e.g., agraphical processor) that outputs graphical content to a display 1240.In some examples, the graphical device 1215 may be integrated within theprocessor 1205. In yet another example, the display 1240 may be integralwith the computer system 1200 (e.g., a laptop, a tablet, a phone, etc.).In some examples, the graphical device 1215 may be integral with theprocessor 1205 and form an accelerated processing unit (APU).

The graphical device 1215 may be optimized to perform floating pointoperations such as graphical computations, and may be configured toexecute other operations in place of the processor 1205. For example,controlled by instructions to perform mathematical operations optimizedfor floating point math. For example, the processor 1205 may allocateinstructions to the graphical device 1215 for operations that areoptimized for the graphical device 1215. For instance, the graphicaldevice 1215 may execute operations related to artificial intelligence(AI), NLP, and vector math. The results may be returned to the processor1205. In another example, the application executing in the processor1205 may provide instructions to cause the processor 1205 to request thegraphical device 1215 to perform the operations. In other examples, thegraphical device 1215 may return the processing results to anothercomputer system (i.e., distributed computing).

The processor 1205 may also control a network device 1220 for transmitsand receives data using a plurality of wireless channels 1245 and atleast one communication standard (e.g., Wi-Fi (i.e., 1202.11ax,1202.11e, etc.), Bluetooth®, various standards provided by the 3rdGeneration Partnership Project (e.g., 3G, 4G, 5G), or a satellitecommunication network (e.g., Starlink®). The network device 1220 maywirelessly connect to a network 1250 to connect to servers 1255 or otherservice providers. The network device 1220 may also be connected to thenetwork 1250 via a physical (i.e., circuit) connection. The networkdevice 1220 may also directly connect to local electronic device 1260using a point-to-point (P2P) or a short-range radio connection.

The processor 1205 may also control an interface 1225 that connects withan external device 1270 for bidirectional or unidirectionalcommunication. The interface 1225 is any suitable interface that forms acircuit connection and can be implemented by any suitable interface(e.g., universal serial bus (USB), Thunderbolt, and so forth). Theexternal device 1270 can receive data from interface 1225 to process thedata or perform functions for different applications executing in theprocessor 1205. For example, the external device 1270 may be anotherdisplay device, a musical instrument, a computer interface device (e.g.,a keyboard, a mouse, etc.), an audio device (e.g., an analog-to-digitalconverter (ADC), a digital-to-analog converter (DAC)), a storage devicefor storing content, an authentication device, an external networkinterface (e.g., a 5G hotspot), a printer, and so forth.

The storage device 1230 can be a non-volatile memory device and can be ahard disk or other types of computer-readable media which can store datathat are accessible by a computer, such as flash memory, solid statememory devices, an electro-mechanical data storage such as a hard diskdrive (HDD), optical storage medium such as digital versatile disks,cartridges, random access memories (RAMs), read only memory (ROM),and/or some combination of these devices. In some embodiments thecomputer-readable storage devices, mediums, and memories can include acable or wireless signal containing a bitstream and the like. However,when mentioned, non-transitory computer-readable storage media expresslyexclude media such as energy, carrier signals, electromagnetic waves,and signals per se.

The storage device 1230 can include software services, servers,services, etc., that, when the code that defines such software isexecuted by the processor 1205, it causes the system to perform afunction. In some embodiments, a hardware service that performs aparticular function can include the software component stored in acomputer-readable medium in connection with the necessary hardwarecomponents, such as processor 1205, connection 1235, external device1270, etc., to carry out the function.

FIG. 13 shows an example of computing system 1300, which can be forexample any computing device making up any network node such as theclient 302, webserver 304, or NLP server 306, or any component thereofin which the components of the system are in communication with eachother using connection 1305. Connection 1305 can be a physicalconnection via a bus, or a direct connection into processor 1310, suchas in a chipset architecture. Connection 1305 can also be a virtualconnection, networked connection, or logical connection.

In some embodiments computing system 1300 is a distributed system inwhich the functions described in this disclosure can be distributedwithin a datacenter, multiple datacenters, a peer network, etc. In someembodiments, one or more of the described system components representsmany such components each performing some or all of the function forwhich the component is described. In some embodiments, the componentscan be physical or virtual devices.

Example computing system 1300 includes at least one processing unit (CPUor processor) 1310 and connection 1305 that couples various systemcomponents including system memory 1315, such as ROM 1320 and RAM 1325to processor 1310. Computing system 1300 can include a cache ofhigh-speed memory 1312 connected directly with, in close proximity to,or integrated as part of processor 1310.

Processor 1310 can include any general-purpose processor and a hardwareservice or software service, such as services 1332, 1334, and 1336stored in storage device 1330, configured to control processor 1310 aswell as a special-purpose processor where software instructions areincorporated into the actual processor design. Processor 1310 mayessentially be a completely self-contained computing system, containingmultiple cores or processors, a bus, memory controller, cache, etc. Amulti-core processor may be symmetric or asymmetric.

To enable user interaction, computing system 1300 includes an inputdevice 1345, which can represent any number of input mechanisms, such asa microphone for speech, a touch-sensitive screen for gesture orgraphical input, keyboard, mouse, motion input, speech, etc. Computingsystem 1300 can also include output device 1335, which can be one ormore of a number of output mechanisms known to those of skill in theart. In some instances, multimodal systems can enable a user to providemultiple types of input/output to communicate with computing system1300. Computing system 1300 can include communications interface 1340,which can generally govern and manage the user input and system output.There is no restriction on operating on any particular hardwarearrangement and therefore the basic features here may easily besubstituted for improved hardware or firmware arrangements as they aredeveloped.

Storage device 1330 can be a non-volatile memory device and can be ahard disk or other types of computer readable media which can store datathat are accessible by a computer, such as magnetic cassettes, flashmemory cards, solid state memory devices, digital versatile disks,cartridges, RAMs, ROMs, and/or some combination of these devices.

The storage device 1330 can include software services, servers,services, etc., that, when the code that defines such software isexecuted by the processor 1310, causes the system to perform a function.In some embodiments, a hardware service that performs a particularfunction can include the software component stored in acomputer-readable medium in connection with the necessary hardwarecomponents, such as processor 1310, connection 1305, output device 1335,etc., to carry out the function.

Devices implementing methods according to these disclosures can comprisehardware, firmware and/or software, and can take any of a variety ofform factors. Typical examples of such form factors include servers,laptops, smart phones, small form factor personal computers, personaldigital assistants, and so on. Functionality described herein also canbe embodied in peripherals or add-in cards. Such functionality can alsobe implemented on a circuit board among different chips or differentprocesses executing in a single device, by way of further example.

For clarity of explanation, in some instances, the present technologymay be presented as including individual functional blocks includingfunctional blocks comprising devices, device components, steps orroutines in a method embodied in software, or combinations of hardwareand software.

Any of the steps, operations, functions, or processes described hereinmay be performed or implemented by a combination of hardware andsoftware services or services, alone or in combination with otherdevices. In some embodiments, a service can be software that resides inmemory of a client device and/or one or more servers of a contentmanagement system and perform one or more functions when a processorexecutes the software associated with the service. In some embodiments,a service is a program, or a collection of programs that carry out aspecific function. In some embodiments, a service can be considered aserver. The memory can be a non-transitory computer-readable medium.

In some embodiments the computer-readable storage devices, mediums, andmemories can include a cable or wireless signal containing a bit streamand the like. However, when mentioned, non-transitory computer-readablestorage media expressly exclude media such as energy, carrier signals,electromagnetic waves, and signals per se.

Methods according to the above-described examples can be implementedusing computer-executable instructions that are stored or otherwiseavailable from computer readable media. Such instructions can comprise,for example, instructions and data which cause or otherwise configure ageneral-purpose computer, special purpose computer, or special purposeprocessing device to perform a certain function or group of functions.Portions of computer resources used can be accessible over a network.The computer executable instructions may be, for example, binaries,intermediate format instructions such as assembly language, firmware, orsource code. Examples of computer-readable media that may be used tostore instructions, information used, and/or information created duringmethods according to described examples include magnetic or opticaldisks, solid state memory devices, flash memory, USB devices providedwith non-volatile memory, networked storage devices, and so on.

Devices implementing methods according to these disclosures can comprisehardware, firmware and/or software, and can take any of a variety ofform factors. Typical examples of such form factors include servers,laptops, smartphones, small form factor personal computers, personaldigital assistants, and so on. Functionality described herein also canbe embodied in peripherals or add-in cards. Such functionality can alsobe implemented on a circuit board among different chips or differentprocesses executing in a single device, by way of further example.

The instructions, media for conveying such instructions, computingresources for executing them, and other structures for supporting suchcomputing resources are means for providing the functions described inthese disclosures.

Although a variety of examples and other information was used to explainaspects within the scope of the appended claims, no limitation of theclaims should be implied based on particular features or arrangements insuch examples, as one of ordinary skill would be able to use theseexamples to derive a wide variety of implementations. Further andalthough some subject matter may have been described in languagespecific to examples of structural features and/or method steps, it isto be understood that the subject matter defined in the appended claimsis not necessarily limited to these described features or acts. Forexample, such functionality can be distributed differently or performedin components other than those identified herein. Rather, the describedfeatures and steps are disclosed as examples of components of systemsand methods within the scope of the appended claims.

In some examples, the system can be implemented in a virtualized and/orcontainer system. For example, the system can be implemented in a singleor multiple Docker containers on a Docker Host. As an example, variousaspects of the system can be separated into different containers toisolate functions (e.g., application, storage, etc.) across a singleDocker host or multiple Docker hosts. In another example, the system canbe implemented in a scalable container system (e.g., a Kubernetescluster) that automatically provisions containers, networking, loadbalancing, security, and scaling of the system.

Illustrative examples of the disclosure include:

Aspect 1. A method for preparing a patent application based on claims,comprising: displaying a user interface for writing a patentapplication, the user interface including a plurality of objects thatcan be converted into content for the patent application; displaying aclaim based on phrases that are separated based on a phrase variant, thephrase variant including at least one of an adjective phrase and a verbphrase; determining that a first phrase of the claim is dragged in theuser interface and dropped into an object of the plurality of objects;creating and displaying a first object within the user interface basedon the first phrase; and converting the plurality of objects in the userinterface into the patent application including content based on theplurality of objects within the user interface.

Aspect 2. The method of Aspect 1, wherein the plurality of objects arenodes within a tree view component.

Aspect 3. The method of any of Aspects 1 to 2, wherein the convertingthe plurality of objects comprises: constructing a sentence based on thefirst phrase, a subject of the first phrase, and a context associatedwith the first phrase.

Aspect 4. The method of any of Aspects 1 to 3, further comprising:identifying a description in a different document or document sectionthat corresponds to a claim term in the first phrase; and injecting thedescription into the sentence based on the description.

Aspect 5. The method of any of Aspects 1 to 4, wherein the descriptioncomprises one of a reference label or a plain English description of theclaim term.

Aspect 6. The method of any of Aspects 1 to 5, further comprising:displaying a user interface that illustrates relevant content in thedocument section or the different document; and identifyingrelationships between at least two of a claim term, a reference label ofa drawing, and a drawing description.

Aspect 7. The method of any of Aspects 1 to 6, wherein the first phraseis immutable in the user interface.

Aspect 8. The method of any of Aspects 1 to 7, further comprising:displaying a user interface to edit the sentence.

Aspect 9. The method of any of Aspects 1 to 8, further comprising:constructing a graph including a plurality of nodes associated with atleast a portion of phrases from a set of claims based on a context and asubject for each phrase of the portion of phrases, wherein the set ofclaims that includes the claim, and wherein each phrase correspond to anode in the graph.

Aspect 10. The method of any of Aspects 1 to 9, further comprising:inserting at least one metadata node into the graph based on a contextof child content, wherein the at least one metadata node defines acollapsible parent node that provides a context associated with childnodes.

Aspect 11. The method of any of Aspects 1 to 10, further comprising:inserting metadata into a document of the patent application thatidentifies at least one object of the plurality of objects in the userinterface.

Aspect 12. The method of any of Aspects 1 to 11, further comprising:reading the document of the patent application and embedded into contentassociated with the document; and restoring a state of the plurality ofobjects based on the metadata.

Aspect 13: A computing system for generating a patent application basedon apparatus claims includes a storage (implemented in circuitry)configured to store instructions and a processor. The processorconfigured to execute the instructions and cause the processor to:display a user interface for writing a patent application, the userinterface including a plurality of objects that can be converted intocontent for the patent application; display a claim based on phrasesthat are separated based on a phrase variant, the phrase variantincluding at least one of an adjective phrase and a verb phrase;determining that a first phrase of the claim is dragged in the userinterface and dropped into an object of the plurality of objects; createand displaying a first object within the user interface based on thefirst phrase; and convert the plurality of objects in the user interfaceinto the patent application including content based on the plurality ofobjects within the user interface.

Aspect 14: The computing system of Aspect 13, wherein the plurality ofobjects are nodes within a tree view component.

Aspect 15: The computing system of any of Aspects 13 to 14, wherein theprocessor is configured to execute the instructions and cause theprocessor to: construct a sentence based on the first phrase, a subjectof the first phrase, and a context associated with the first phrase.

Aspect 16: The computing system of any of Aspects 13 to 15, wherein theprocessor is configured to execute the instructions and cause theprocessor to: identify a description in a different document or documentsection that corresponds to a claim term in the first phrase; and injectthe description into the sentence based on the description.

Aspect 17: The computing system of any of Aspects 13 to 16, wherein thedescription comprises one of a reference label or a plain Englishdescription of the claim term.

Aspect 18: The computing system of any of Aspects 13 to 17, wherein theprocessor is configured to execute the instructions and cause theprocessor to: display a user interface that illustrates relevant contentin the document section or the different document; and identifyrelationships between at least two of a claim term, a reference label ofa drawing, and a drawing description.

Aspect 19: The computing system of any of Aspects 13 to 18, wherein thefirst phrase is immutable in the user interface.

Aspect 20: The computing system of any of Aspects 13 to 19, wherein theprocessor is configured to execute the instructions and cause theprocessor to: display a user interface to edit the sentence.

Aspect 21: The computing system of any of Aspects 13 to 20, wherein theprocessor is configured to execute the instructions and cause theprocessor to: construct a graph including a plurality of nodesassociated with at least a portion of phrases from a set of claims basedon a context and a subject for each phrase of the portion of phrases,wherein the set of claims that includes the claim, and wherein eachphrase correspond to a node in the graph.

Aspect 22: The computing system of any of Aspects 13 to 21, wherein theprocessor is configured to execute the instructions and cause theprocessor to: insert at least one metadata node into the graph based ona context of child content, wherein the at least one metadata nodedefines a collapsible parent node that provides a context associatedwith child nodes.

Aspect 23: The computing system of any of Aspects 13 to 22, wherein theprocessor is configured to execute the instructions and cause theprocessor to: insert metadata into a document of the patent applicationthat identifies at least one object of the plurality of objects in theuser interface.

Aspect 24: The computing system of any of Aspects 13 to 23, wherein theprocessor is configured to execute the instructions and cause theprocessor to: read the document of the patent application and embeddedinto content associated with the document; and restore a state of theplurality of objects based on the metadata.

Aspect 25: A computer readable medium comprising instructions using acomputer system. The computer includes a memory (e.g., implemented incircuitry) and a processor (or multiple processors) coupled to thememory. The processor (or processors) is configured to execute thecomputer readable medium and cause the processor to: display a userinterface for writing a patent application, the user interface includinga plurality of objects that can be converted into content for the patentapplication; display a claim based on phrases that are separated basedon a phrase variant, the phrase variant including at least one of anadjective phrase and a verb phrase; determining that a first phrase ofthe claim is dragged in the user interface and dropped into an object ofthe plurality of objects; create and displaying a first object withinthe user interface based on the first phrase; and convert the pluralityof objects in the user interface into the patent application includingcontent based on the plurality of objects within the user interface.

Aspect 26: The computer readable medium of Aspect 25, wherein theplurality of objects are nodes within a tree view component.

Aspect 27: The computer readable medium of any of Aspects 25 to 26,wherein the processor is configured to execute the computer readablemedium and cause the processor to: construct a sentence based on thefirst phrase, a subject of the first phrase, and a context associatedwith the first phrase.

Aspect 28: The computer readable medium of any of Aspects 25 to 27,wherein the processor is configured to execute the computer readablemedium and cause the processor to: identify a description in a differentdocument or document section that corresponds to a claim term in thefirst phrase; and inject the description into the sentence based on thedescription.

Aspect 29: The computer readable medium of any of Aspects 25 to 28,wherein the description comprises one of a reference label or a plainEnglish description of the claim term.

Aspect 30: The computer readable medium of any of Aspects 25 to 29,wherein the processor is configured to execute the computer readablemedium and cause the processor to: display a user interface thatillustrates relevant content in the document section or the differentdocument; and identify relationships between at least two of a claimterm, a reference label of a drawing, and a drawing description.

Aspect 31: The computer readable medium of any of Aspects 25 to 30,wherein the first phrase is immutable in the user interface.

Aspect 32: The computer readable medium of any of Aspects 25 to 31,wherein the processor is configured to execute the computer readablemedium and cause the processor to: display a user interface to edit thesentence.

Aspect 33: The computer readable medium of any of Aspects 25 to 32,wherein the processor is configured to execute the computer readablemedium and cause the processor to: construct a graph including aplurality of nodes associated with at least a portion of phrases from aset of claims based on a context and a subject for each phrase of theportion of phrases, wherein the set of claims that includes the claim,and wherein each phrase correspond to a node in the graph.

Aspect 34: The computer readable medium of any of Aspects 25 to 33,wherein the processor is configured to execute the computer readablemedium and cause the processor to: insert at least one metadata nodeinto the graph based on a context of child content, wherein the at leastone metadata node defines a collapsible parent node that provides acontext associated with child nodes.

Aspect 35: The computer readable medium of any of Aspects 25 to 34,wherein the processor is configured to execute the computer readablemedium and cause the processor to: insert metadata into a document ofthe patent application that identifies at least one object of theplurality of objects in the user interface.

Aspect 36: The computer readable medium of any of Aspects 25 to 35,wherein the processor is configured to execute the computer readablemedium and cause the processor to: read the document of the patentapplication and embedded into content associated with the document; andrestore a state of the plurality of objects based on the metadata.

1. A method for preparing a patent application based on claims,comprising: displaying a user interface for writing a patentapplication, the user interface including a plurality of objects thatcan be converted into content for the patent application; displaying aclaim based on phrases that are separated based on a phrase variant, thephrase variant including at least one of an adjective phrase and a verbphrase; determining that a first phrase of the claim is dragged in theuser interface and dropped into an object of the plurality of objects;creating and displaying a first object within the user interface basedon the first phrase; and converting the plurality of objects in the userinterface into the patent application including content based on theplurality of objects within the user interface.
 2. The method of claim1, wherein the plurality of objects are nodes within a tree viewcomponent.
 3. The method of claim 2, wherein the converting theplurality of objects comprises: constructing a sentence based on thefirst phrase, a subject of the first phrase, and a context associatedwith the first phrase.
 4. The method of claim 3, further comprising:identifying a description in a different document or document sectionthat corresponds to a claim term in the first phrase; and injecting thedescription into the sentence based on the description.
 5. The method ofclaim 4, wherein the description comprises one of a reference label or aplain English description of the claim term.
 6. The method of claim 4,further comprising: displaying a user interface that illustratesrelevant content in the document section or the different document; andidentifying relationships between at least two of a claim term, areference label of a drawing, and a drawing description.
 7. The methodof claim 3, further comprising: displaying a user interface to edit thesentence.
 8. The method of claim 6, wherein the first phrase isimmutable in the user interface.
 9. The method of claim 1, furthercomprising: constructing a graph including a plurality of nodesassociated with at least a portion of phrases from a set of claims basedon a context and a subject for each phrase of the portion of phrases,wherein the set of claims that includes the claim, and wherein eachphrase correspond to a node in the graph.
 10. The method of claim 9,further comprising: inserting at least one metadata node into the graphbased on a context of child content, wherein the at least one metadatanode defines a collapsible parent node that provides a contextassociated with child nodes.
 11. The method of claim 1, furthercomprising: inserting metadata into a document of the patent applicationthat identifies at least one object of the plurality of objects in theuser interface.
 12. The method of claim 11, further comprising: readingthe document of the patent application and embedded into contentassociated with the document; and restoring a state of the plurality ofobjects based on the metadata.
 13. A computing system for generating apatent application based on apparatus claims, comprising: a storageconfigured to store instructions; a processor configured to execute theinstructions and cause the processor to: display a user interface forwriting a patent application, the user interface including a pluralityof objects that can be converted into content for the patentapplication; display a claim based on phrases that are separated basedon a phrase variant, the phrase variant including at least one of anadjective phrase and a verb phrase; determining that a first phrase ofthe claim is dragged in the user interface and dropped into an object ofthe plurality of objects; create and displaying a first object withinthe user interface based on the first phrase; and convert the pluralityof objects in the user interface into the patent application includingcontent based on the plurality of objects within the user interface. 14.The computing system of claim 13, wherein the plurality of objects arenodes within a tree view component.
 15. The computing system of claim14, wherein the processor is configured to execute the instructions andcause the processor to: construct a sentence based on the first phrase,a subject of the first phrase, and a context associated with the firstphrase.
 16. The computing system of claim 15, wherein the processor isconfigured to execute the instructions and cause the processor to:identify a description in a different document or document section thatcorresponds to a claim term in the first phrase; and inject thedescription into the sentence based on the description.
 17. Thecomputing system of claim 16, wherein the description comprises one of areference label or a plain English description of the claim term. 18.The computing system of claim 16, wherein the processor is configured toexecute the instructions and cause the processor to: display a userinterface that illustrates relevant content in the document section orthe different document; and identify relationships between at least twoof a claim term, a reference label of a drawing, and a drawingdescription.
 19. The computing system of claim 18, wherein the firstphrase is immutable in the user interface.
 20. A non-transitory computerreadable medium comprising instructions, the instructions, when executedby a computing system, cause the computing system to: display a userinterface for writing a patent application, the user interface includinga plurality of objects that can be converted into content for the patentapplication; display a claim based on phrases that are separated basedon a phrase variant, the phrase variant including at least one of anadjective phrase and a verb phrase; determining that a first phrase ofthe claim is dragged in the user interface and dropped into an object ofthe plurality of objects; create and displaying a first object withinthe user interface based on the first phrase; and convert the pluralityof objects in the user interface into the patent application includingcontent based on the plurality of objects within the user interface.